home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / VideoToolbox 96.06.15 / VideoToolboxSources / Mean.c < prev    next >
Text File  |  1995-05-27  |  4KB  |  240 lines
  1. /*
  2. Mean.c
  3.     mean=Mean(x,n,&sd);
  4.     mean=MeanF(x,n,&sd);
  5.     mean=MeanB(x,n,&sd);
  6.     mean=MeanUB(x,n,&sd);
  7.     mean=MeanW(x,n,&sd);
  8.     mean=MeanUW(x,n,&sd);
  9.     mean=MeanL(x,n,&sd);
  10.     mean=MeanUL(x,n,&sd);
  11. Quickly compute mean (and optionally the standard deviation) of an array x[] of
  12. n samples. The various routines differ only in the assumed type of x[]: double,
  13. char, short, or long, either signed or unsigned. The standard deviation is computed
  14. only if the last argument is not NULL. The loops have been optimized
  15. to do only one memory access per iteration.
  16.  
  17. HISTORY:
  18. 9/16/90    dgp    wrote it.
  19. 1/10/94    dgp added MeanB and MeanUB that operate on arrays of signed char and 
  20.             unsigned char.
  21.             Optimized to minimize memory accesses when compiled by THINK C 6.01.
  22. 1/25/94    dgp added MeanW, MeanUW, MeanL, and MeanUL.
  23. */
  24. #include "VideoToolbox.h"
  25. double MeanF(float x[],long n,double *sdPtr);
  26.  
  27. double Mean(double x[],long n,double *sdPtr)
  28. {
  29.     register double s;
  30.     register long i;
  31.     double *p;
  32.  
  33.     p=x;
  34.     if(sdPtr!=NULL){
  35.         register double ss;
  36.         register double xx;
  37.  
  38.         s=ss=0.0;
  39.         for(i=n;i>0;i--){
  40.             s+=xx=*p++;
  41.             ss+=xx*xx;
  42.         }
  43.         s/=n;
  44.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  45.         else *sdPtr=0;
  46.     }else{
  47.         s=0.0;
  48.         for(i=n;i>0;i--) s+=*p++;
  49.         s/=n;
  50.     }
  51.     return s;
  52. }
  53.  
  54. double MeanF(float x[],long n,double *sdPtr)
  55. {
  56.     register double s;
  57.     register long i;
  58.     float *p;
  59.  
  60.     p=x;
  61.     if(sdPtr!=NULL){
  62.         register double ss;
  63.         register double xx;
  64.  
  65.         s=ss=0.0;
  66.         for(i=n;i>0;i--){
  67.             s+=xx=*p++;
  68.             ss+=xx*xx;
  69.         }
  70.         s/=n;
  71.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  72.         else *sdPtr=0;
  73.     }else{
  74.         s=0.0;
  75.         for(i=n;i>0;i--) s+=*p++;
  76.         s/=n;
  77.     }
  78.     return s;
  79. }
  80.  
  81. double MeanB(char x[],long n,double *sdPtr)
  82. {
  83.     register double s;
  84.     register long i;
  85.     register char *p;
  86.  
  87.     p=x;
  88.     if(sdPtr!=NULL){
  89.         register double ss;
  90.         register long xx;
  91.  
  92.         s=ss=0.0;
  93.         for(i=n;i>0;i--){
  94.             s+=xx=*p++;
  95.             ss+=xx*xx;
  96.         }
  97.         s/=n;
  98.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  99.         else *sdPtr=0;
  100.     }else{
  101.         s=0.0;
  102.         for(i=n;i>0;i--) s+=*p++;
  103.         s/=n;
  104.     }
  105.     return s;
  106. }
  107.  
  108. double MeanUB(unsigned char x[],long n,double *sdPtr)
  109. {
  110.     register double s;
  111.     register long i;
  112.     register unsigned char *p;
  113.  
  114.     p=x;
  115.     if(sdPtr!=NULL){
  116.         register double ss;
  117.         register long xx;
  118.  
  119.         s=ss=0.0;
  120.         for(i=n;i>0;i--){
  121.             s+=xx=*p++;
  122.             ss+=xx*xx;
  123.         }
  124.         s/=n;
  125.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  126.         else *sdPtr=0;
  127.     }else{
  128.         s=0.0;
  129.         for(i=n;i>0;i--) s+=*p++;
  130.         s/=n;
  131.     }
  132.     return s;
  133. }
  134.  
  135. double MeanW(short x[],long n,double *sdPtr)
  136. {
  137.     register double s;
  138.     register long i;
  139.     register short *p;
  140.  
  141.     p=x;
  142.     if(sdPtr!=NULL){
  143.         register double ss;
  144.         register long xx;
  145.  
  146.         s=ss=0.0;
  147.         for(i=n;i>0;i--){
  148.             s+=xx=*p++;
  149.             ss+=xx*xx;
  150.         }
  151.         s/=n;
  152.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  153.         else *sdPtr=0;
  154.     }else{
  155.         s=0.0;
  156.         for(i=n;i>0;i--) s+=*p++;
  157.         s/=n;
  158.     }
  159.     return s;
  160. }
  161.  
  162. double MeanUW(unsigned short x[],long n,double *sdPtr)
  163. {
  164.     register double s;
  165.     register long i;
  166.     register unsigned short *p;
  167.  
  168.     p=x;
  169.     if(sdPtr!=NULL){
  170.         register double ss;
  171.         register unsigned long xx;
  172.  
  173.         s=ss=0.0;
  174.         for(i=n;i>0;i--){
  175.             s+=xx=*p++;
  176.             ss+=xx*xx;
  177.         }
  178.         s/=n;
  179.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  180.         else *sdPtr=0;
  181.     }else{
  182.         s=0.0;
  183.         for(i=n;i>0;i--) s+=*p++;
  184.         s/=n;
  185.     }
  186.     return s;
  187. }
  188.  
  189. double MeanL(long x[],long n,double *sdPtr)
  190. {
  191.     register double s;
  192.     register long i;
  193.     register long *p;
  194.  
  195.     p=x;
  196.     if(sdPtr!=NULL){
  197.         register double ss,xx;
  198.  
  199.         s=ss=0.0;
  200.         for(i=n;i>0;i--){
  201.             s+=xx=*p++;
  202.             ss+=xx*xx;
  203.         }
  204.         s/=n;
  205.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  206.         else *sdPtr=0;
  207.     }else{
  208.         s=0.0;
  209.         for(i=n;i>0;i--) s+=*p++;
  210.         s/=n;
  211.     }
  212.     return s;
  213. }
  214.  
  215. double MeanUL(unsigned long x[],long n,double *sdPtr)
  216. {
  217.     register double s;
  218.     register long i;
  219.     register unsigned long *p;
  220.  
  221.     p=x;
  222.     if(sdPtr!=NULL){
  223.         register double ss,xx;
  224.  
  225.         s=ss=0.0;
  226.         for(i=n;i>0;i--){
  227.             s+=xx=*p++;
  228.             ss+=xx*xx;
  229.         }
  230.         s/=n;
  231.         if(n>1)*sdPtr=sqrt((ss-n*s*s)/(n-1));
  232.         else *sdPtr=0;
  233.     }else{
  234.         s=0.0;
  235.         for(i=n;i>0;i--) s+=*p++;
  236.         s/=n;
  237.     }
  238.     return s;
  239. }
  240.